home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_cgi.py < prev    next >
Text File  |  2005-10-18  |  7KB  |  207 lines
  1. from test.test_support import verify, verbose
  2. import cgi
  3. import os
  4. import sys
  5.  
  6. class HackedSysModule:
  7.     # The regression test will have real values in sys.argv, which
  8.     # will completely confuse the test of the cgi module
  9.     argv = []
  10.     stdin = sys.stdin
  11.  
  12. cgi.sys = HackedSysModule()
  13.  
  14. try:
  15.     from cStringIO import StringIO
  16. except ImportError:
  17.     from StringIO import StringIO
  18.  
  19. class ComparableException:
  20.     def __init__(self, err):
  21.         self.err = err
  22.  
  23.     def __str__(self):
  24.         return str(self.err)
  25.  
  26.     def __cmp__(self, anExc):
  27.         if not isinstance(anExc, Exception):
  28.             return -1
  29.         x = cmp(self.err.__class__, anExc.__class__)
  30.         if x != 0:
  31.             return x
  32.         return cmp(self.err.args, anExc.args)
  33.  
  34.     def __getattr__(self, attr):
  35.         return getattr(self.err, attr)
  36.  
  37. def do_test(buf, method):
  38.     env = {}
  39.     if method == "GET":
  40.         fp = None
  41.         env['REQUEST_METHOD'] = 'GET'
  42.         env['QUERY_STRING'] = buf
  43.     elif method == "POST":
  44.         fp = StringIO(buf)
  45.         env['REQUEST_METHOD'] = 'POST'
  46.         env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
  47.         env['CONTENT_LENGTH'] = str(len(buf))
  48.     else:
  49.         raise ValueError, "unknown method: %s" % method
  50.     try:
  51.         return cgi.parse(fp, env, strict_parsing=1)
  52.     except StandardError, err:
  53.         return ComparableException(err)
  54.  
  55. # A list of test cases.  Each test case is a a two-tuple that contains
  56. # a string with the query and a dictionary with the expected result.
  57.  
  58. parse_qsl_test_cases = [
  59.     ("", []),
  60.     ("&", []),
  61.     ("&&", []),
  62.     ("=", [('', '')]),
  63.     ("=a", [('', 'a')]),
  64.     ("a", [('a', '')]),
  65.     ("a=", [('a', '')]),
  66.     ("a=", [('a', '')]),
  67.     ("&a=b", [('a', 'b')]),
  68.     ("a=a+b&b=b+c", [('a', 'a b'), ('b', 'b c')]),
  69.     ("a=1&a=2", [('a', '1'), ('a', '2')]),
  70. ]
  71.  
  72. parse_strict_test_cases = [
  73.     ("", ValueError("bad query field: ''")),
  74.     ("&", ValueError("bad query field: ''")),
  75.     ("&&", ValueError("bad query field: ''")),
  76.     (";", ValueError("bad query field: ''")),
  77.     (";&;", ValueError("bad query field: ''")),
  78.     # Should the next few really be valid?
  79.     ("=", {}),
  80.     ("=&=", {}),
  81.     ("=;=", {}),
  82.     # This rest seem to make sense
  83.     ("=a", {'': ['a']}),
  84.     ("&=a", ValueError("bad query field: ''")),
  85.     ("=a&", ValueError("bad query field: ''")),
  86.     ("=&a", ValueError("bad query field: 'a'")),
  87.     ("b=a", {'b': ['a']}),
  88.     ("b+=a", {'b ': ['a']}),
  89.     ("a=b=a", {'a': ['b=a']}),
  90.     ("a=+b=a", {'a': [' b=a']}),
  91.     ("&b=a", ValueError("bad query field: ''")),
  92.     ("b&=a", ValueError("bad query field: 'b'")),
  93.     ("a=a+b&b=b+c", {'a': ['a b'], 'b': ['b c']}),
  94.     ("a=a+b&a=b+a", {'a': ['a b', 'b a']}),
  95.     ("x=1&y=2.0&z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  96.     ("x=1;y=2.0&z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  97.     ("x=1;y=2.0;z=2-3.%2b0", {'x': ['1'], 'y': ['2.0'], 'z': ['2-3.+0']}),
  98.     ("Hbc5161168c542333633315dee1182227:key_store_seqid=400006&cuyer=r&view=bustomer&order_id=0bb2e248638833d48cb7fed300000f1b&expire=964546263&lobale=en-US&kid=130003.300038&ss=env",
  99.      {'Hbc5161168c542333633315dee1182227:key_store_seqid': ['400006'],
  100.       'cuyer': ['r'],
  101.       'expire': ['964546263'],
  102.       'kid': ['130003.300038'],
  103.       'lobale': ['en-US'],
  104.       'order_id': ['0bb2e248638833d48cb7fed300000f1b'],
  105.       'ss': ['env'],
  106.       'view': ['bustomer'],
  107.       }),
  108.  
  109.     ("group_id=5470&set=custom&_assigned_to=31392&_status=1&_category=100&SUBMIT=Browse",
  110.      {'SUBMIT': ['Browse'],
  111.       '_assigned_to': ['31392'],
  112.       '_category': ['100'],
  113.       '_status': ['1'],
  114.       'group_id': ['5470'],
  115.       'set': ['custom'],
  116.       })
  117.     ]
  118.  
  119. def norm(list):
  120.     if type(list) == type([]):
  121.         list.sort()
  122.     return list
  123.  
  124. def first_elts(list):
  125.     return map(lambda x:x[0], list)
  126.  
  127. def first_second_elts(list):
  128.     return map(lambda p:(p[0], p[1][0]), list)
  129.  
  130. def main():
  131.     for orig, expect in parse_qsl_test_cases:
  132.         result = cgi.parse_qsl(orig, keep_blank_values=True)
  133.         print repr(orig), '=>', result
  134.         verify(result == expect, "Error parsing %s" % repr(orig))
  135.  
  136.     for orig, expect in parse_strict_test_cases:
  137.         # Test basic parsing
  138.         print repr(orig)
  139.         d = do_test(orig, "GET")
  140.         verify(d == expect, "Error parsing %s" % repr(orig))
  141.         d = do_test(orig, "POST")
  142.         verify(d == expect, "Error parsing %s" % repr(orig))
  143.  
  144.         env = {'QUERY_STRING': orig}
  145.         fcd = cgi.FormContentDict(env)
  146.         sd = cgi.SvFormContentDict(env)
  147.         fs = cgi.FieldStorage(environ=env)
  148.         if type(expect) == type({}):
  149.             # test dict interface
  150.             verify(len(expect) == len(fcd))
  151.             verify(norm(expect.keys()) == norm(fcd.keys()))
  152.             verify(norm(expect.values()) == norm(fcd.values()))
  153.             verify(norm(expect.items()) == norm(fcd.items()))
  154.             verify(fcd.get("nonexistent field", "default") == "default")
  155.             verify(len(sd) == len(fs))
  156.             verify(norm(sd.keys()) == norm(fs.keys()))
  157.             verify(fs.getvalue("nonexistent field", "default") == "default")
  158.             # test individual fields
  159.             for key in expect.keys():
  160.                 expect_val = expect[key]
  161.                 verify(fcd.has_key(key))
  162.                 verify(norm(fcd[key]) == norm(expect[key]))
  163.                 verify(fcd.get(key, "default") == fcd[key])
  164.                 verify(fs.has_key(key))
  165.                 if len(expect_val) > 1:
  166.                     single_value = 0
  167.                 else:
  168.                     single_value = 1
  169.                 try:
  170.                     val = sd[key]
  171.                 except IndexError:
  172.                     verify(not single_value)
  173.                     verify(fs.getvalue(key) == expect_val)
  174.                 else:
  175.                     verify(single_value)
  176.                     verify(val == expect_val[0])
  177.                     verify(fs.getvalue(key) == expect_val[0])
  178.                 verify(norm(sd.getlist(key)) == norm(expect_val))
  179.                 if single_value:
  180.                     verify(norm(sd.values()) == \
  181.                            first_elts(norm(expect.values())))
  182.                     verify(norm(sd.items()) == \
  183.                            first_second_elts(norm(expect.items())))
  184.  
  185.     # Test the weird FormContentDict classes
  186.     env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"}
  187.     expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'}
  188.     d = cgi.InterpFormContentDict(env)
  189.     for k, v in expect.items():
  190.         verify(d[k] == v)
  191.     for k, v in d.items():
  192.         verify(expect[k] == v)
  193.     verify(norm(expect.values()) == norm(d.values()))
  194.  
  195.     print "Testing log"
  196.     cgi.log("Testing")
  197.     cgi.logfp = sys.stdout
  198.     cgi.initlog("%s", "Testing initlog 1")
  199.     cgi.log("%s", "Testing log 2")
  200.     if os.path.exists("/dev/null"):
  201.         cgi.logfp = None
  202.         cgi.logfile = "/dev/null"
  203.         cgi.initlog("%s", "Testing log 3")
  204.         cgi.log("Testing log 4")
  205.  
  206. main()
  207.